if E2Helper then

-- Number
E2Helper.Descriptions["mod(n n)"] = "Modulo, returns the Remainder after Argument 1 has been divided by Argument 2. Note \"mod(-1, 3) = -1\""
E2Helper.Descriptions["sqrt(n)"] = "Returns the Square Root of the Argument"
E2Helper.Descriptions["cbrt(n)"] = "Returns the Cube Root of the Argument"
E2Helper.Descriptions["root(n n)"] = "Returns the Nth Root of the first Argument"
E2Helper.Descriptions["e()"] = "Returns Euler's Constant"
E2Helper.Descriptions["exp(n)"] = "Returns e to the power of the Argument (same as e()^N but shorter and faster this way)"
E2Helper.Descriptions["ln(n)"] = " Returns the logarithm to base e of the Argument"
E2Helper.Descriptions["log2(n)"] = "Returns the logarithm to base 2 of the Argument"
E2Helper.Descriptions["log10(n)"] = " Returns the logarithm to base 10 of the Argument"
E2Helper.Descriptions["log(nn)"] = " Returns the logarithm to base Argument 2 of Argument 1"
E2Helper.Descriptions["abs(n)"] = "Returns the Magnitude of the Argument"
E2Helper.Descriptions["ceil(n)"] = "Rounds the Argument up to the nearest Integer"
E2Helper.Descriptions["ceil(nn)"] = "Rounds Argument 1 up to Argument 2's decimal precision"
E2Helper.Descriptions["floor(n)"] = "Rounds the Argument down to the nearest Integer"
E2Helper.Descriptions["floor(nn)"] = "Rounds Argument 1 down to Argument 2's decimal precision"
E2Helper.Descriptions["round(n)"] = "Rounds the Argument to the nearest Integer"
E2Helper.Descriptions["round(nn)"] = " Rounds Argument 1 to Argument 2's decimal precision"
E2Helper.Descriptions["int(n)"] = "Returns the Integer part of the Argument (same as floor)"
E2Helper.Descriptions["frac(n)"] = "Returns the Fractional part of the Argument (same as floor)"
E2Helper.Descriptions["clamp(nnn)"] = "If Arg1 = Arg3 (max) returns Arg3; otherwise returns Arg1."
E2Helper.Descriptions["inrange(nn2n3)"] = "Returns 1 if N is in the interval [N2; N3], 0 otherwise. This means it is equivalent to ((N2 <= N) & (N <= N3))"
E2Helper.Descriptions["sign(n)"] = "Returns the sign of argument (-1,0,1) [sign(N) = N / abs(N) ]"
E2Helper.Descriptions["min(nn)"] = "Returns the lowest value Argument"
E2Helper.Descriptions["min(nnn)"] = "Returns the lowest value Argument"
E2Helper.Descriptions["min(nnnn)"] = "Returns the lowest value Argument"
E2Helper.Descriptions["max(nn)"] = "Returns the highest value Argument"
E2Helper.Descriptions["max(nnn)"] = "Returns the highest value Argument"
E2Helper.Descriptions["max(nnnn)"] = "Returns the highest value Argument"
E2Helper.Descriptions["random()"] = "Returns a random floating-point number between 0 and 1 [0 <= x < 1 ]"
E2Helper.Descriptions["random(n)"] = "Returns a random floating-point number between 0 and the specified value [0 <= x < a ]"
E2Helper.Descriptions["random(nn)"] = "Returns a random floating-point number between the specified interval [a <= x < b ]"
E2Helper.Descriptions["randint(n)"] = "Returns a random integer from 1 to the specified value [1 <= x <= a ]"
E2Helper.Descriptions["randint(nn)"] = "Returns a random integer in the specified interval [a <= x <= b ]"
E2Helper.Descriptions["pi()"] = "Returns the constant PI"
E2Helper.Descriptions["toRad(n)"] = "Converts Degree angles to Radian angles"
E2Helper.Descriptions["toDeg(n)"] = "Converts Radian angles to Degree angles"
E2Helper.Descriptions["sin(n)"] = "Returns the sine of N degrees "
E2Helper.Descriptions["cos(n)"] = "Returns the cosine of N degrees "
E2Helper.Descriptions["tan(n)"] = "Returns the tangent of N degrees "
E2Helper.Descriptions["cot(n)"] = "Returns the cotangent of N degrees "
E2Helper.Descriptions["sec(n)"] = "Returns the secant of N degrees "
E2Helper.Descriptions["csc(n)"] = "Returns the cosecant of N degrees "
E2Helper.Descriptions["asin(n)"] = "Returns the inverse sine of the argument, in degrees"
E2Helper.Descriptions["acos(n)"] = "Returns the inverse cosine of the argument, in degrees"
E2Helper.Descriptions["atan(n)"] = "Returns the inverse tangent of the argument, in degrees"
E2Helper.Descriptions["sinh(n)"] = "Returns the hyperbolic sine of N"
E2Helper.Descriptions["cosh(n)"] = "Returns the hyperbolic cosine of N"
E2Helper.Descriptions["tanh(n)"] = "Returns the hyperbolic tangent of N"
E2Helper.Descriptions["coth(n)"] = "Returns the hyperbolic cotangent of N"
E2Helper.Descriptions["sech(n)"] = "Returns the hyperbolic secant of N "
E2Helper.Descriptions["csch(n)"] = "Returns the hyperbolic cosecant of N "
E2Helper.Descriptions["sinr(n)"] = "Returns the sine of N radians "
E2Helper.Descriptions["cosr(n)"] = "Returns the cosine of N radians "
E2Helper.Descriptions["tanr(n)"] = "Returns the tangent of N radians "
E2Helper.Descriptions["cotr(n)"] = "Returns the cotangent of N radians"
E2Helper.Descriptions["secr(n)"] = "Returns the secant of N radians "
E2Helper.Descriptions["cscr(n)"] = "Returns the cosecant of N radians"
E2Helper.Descriptions["asinr(n)"] = "Returns the inverse sine of the argument, in radians"
E2Helper.Descriptions["acosr(n)"] = "Returns the inverse cosine of the argument, in radians"
E2Helper.Descriptions["atanr(n)"] = "Returns the inverse tangent of the argument, in radians"
E2Helper.Descriptions["atanr(nn)"] = "Returns the inverse tangent of the arguments (arg1 / arg2), in radians. This function accounts for positive/negative arguments, and arguments at or close to 0"

-- String
E2Helper.Descriptions["index(s:n)"] = "Returns Nth letter of the string, formatted as a string."
E2Helper.Descriptions["length(s:)"] = "Returns the length of the string."
E2Helper.Descriptions["upper(s:)"] = "All characters are made uppercase"
E2Helper.Descriptions["lower(s:)"] = "All characters are made lowercase"
E2Helper.Descriptions["sub(s:n)"] = "Returns a substring, starting at the number argument and ending at the end of the string"
E2Helper.Descriptions["sub(s:nn)"] = "Returns a substring, starting at the first number argument and ending at the second"
E2Helper.Descriptions["left(s:n)"] = "Returns N amount of characters starting from the leftmost character"
E2Helper.Descriptions["right(s:n)"] = "Returns N amount of characters starting from the rightmost character"
E2Helper.Descriptions["find(s:s)"] = "Returns the 1st occurrence of the string S, returns 0 if not found"
E2Helper.Descriptions["find(s:s n)"] = "Returns the 1st occurrence of the string S starting at N and going to the end of the string, returns 0 if not found"
E2Helper.Descriptions["findRE(s:s)"] = "Returns the 1st occurrence of the string S using REGEX functions, returns 0 if not found"
E2Helper.Descriptions["findRE(s:s n)"] = "Returns the 1st occurrence of the string S starting at N and going to the end of the string using REGEX functions, returns 0 if not found"
E2Helper.Descriptions["explode(s:s)"] = "Splits the string into an array, along the boundaries formed by the string S. See also String.Explode"
E2Helper.Descriptions["repeat(s:n)"] = "Repeats the input string N times"
E2Helper.Descriptions["trim(s:)"] = "Trims away spaces at the beginning and end of a string"
E2Helper.Descriptions["trimLeft(s:)"] = "Trims away opening spaces on the string"
E2Helper.Descriptions["trimRight(s:)"] = "Trims away spaces at the end of a string"
E2Helper.Descriptions["replace(s:ss)"] = "Finds and replaces every occurrence of the first argument with the second argument"
E2Helper.Descriptions["replaceRE(s:ss)"] = "Finds and replaces every occurrence of the first argument using REGEX with the second argument"
E2Helper.Descriptions["reverse(s:)"] = "Returns a reversed version of S"
E2Helper.Descriptions["toNumber(s:)"] = "Parses a number from a string."
E2Helper.Descriptions["toNumber(s:n)"] = "Parses a number from a string. The argument given is the base. I.e. toNumber(16) will parse hex."
E2Helper.Descriptions["toString(n)"] = "Formats a number as a string. (Numbers may be concatenated into a string without using this function)"
E2Helper.Descriptions["toString(nn)"] = "Formats a number as a string, using argument 2 as the base. i.e. using 16 for base would convert the number to hex."
E2Helper.Descriptions["toChar(n)"] = "Returns a one-character string from its [http://en.wikipedia.org/wiki/ASCII ASCII code], where 32 = argument 1 = 255. An empty string is returned for numbers outside that range."
E2Helper.Descriptions["toByte(s)"] = "Returns the ASCII code of the 1st character in the string"
E2Helper.Descriptions["toByte(sn)"] = "Returns the ASCII code of the Nth character in the string"
E2Helper.Descriptions["format(s...)"] = "Formats a values exactly like Lua's [http://www.lua.org/manual/5.1/manual.html#pdf-string.format string.format]. Any number and type of parameter can be passed through the \"...\". Prints errors to the chat area."
E2Helper.Descriptions["match(s:s2)"] = "runs string.match(S, S2) and returns the sub-captures as an array."
E2Helper.Descriptions["match(s:s2n)"] = "runs string.match(S, S2, N) and returns the sub-captures as an array."
E2Helper.Descriptions["matchFirst(s:s2)"] = "runs string.match(S, S2) and returns the first match or an empty string if the match failed."
E2Helper.Descriptions["matchFirst(s:s2n)"] = "runs string.match(S, S2, N) and returns the first match or an empty string if the match failed."
E2Helper.Descriptions["gmatch(s:s2)"] = "runs string.gmatch(S, S2) and returns the captures in an array."
E2Helper.Descriptions["gmatch(s:s2n)"] = "runs string.gmatch(S, S2, N) and returns the captures in an array."

-- Entity/Player
E2Helper.Descriptions["entity(n)"] = "Gets the entity associated with the id"
E2Helper.Descriptions["owner()"] = "Gets the owner of the expression ( same as entity():owner() )"
E2Helper.Descriptions["id(e:)"] = "Gets the numeric id of an entity"
E2Helper.Descriptions["noentity()"] = "Returns an invalid entity"
E2Helper.Descriptions["type(e:)"] = "Gets the class of an entity"
E2Helper.Descriptions["model(e:)"] = "Gets the model of an entity"
E2Helper.Descriptions["owner(e:)"] = "Gets the owner of an entity"
E2Helper.Descriptions["name(e:)"] = "Gets the name of a player "
E2Helper.Descriptions["steamID(e:)"] = "Gets the steam ID of the player"
E2Helper.Descriptions["isSteamFriend(e:e)"] = "Returns if the given Entity is a steam friend of the first Entity"
E2Helper.Descriptions["steamFriends(e:)"] = "Returns a Array with E's steam friends on the server E is playing on"
E2Helper.Descriptions["pos(e:)"] = "Gets the position of the entity"
E2Helper.Descriptions["eye(e:)"] = "Gets a players view direction else entity forward direction"
E2Helper.Descriptions["eyeAngles(e:)"] = "Gets a players view direction"
E2Helper.Descriptions["eyeTrace(e:)"] = "Equivalent to rangerOffset(16384, E:shootPos(), E:eye()), but faster (causing less lag)"
E2Helper.Descriptions["shootPos(e:)"] = "Returns a players shoot position"
E2Helper.Descriptions["aimEntity(e:)"] = "Returns the entity that the entity is aiming at"
E2Helper.Descriptions["aimBone(e:)"] = "Returns the bone the player is currently aiming at"
E2Helper.Descriptions["aimPos(e:)"] = "Returns the point that the entity is looking at"
E2Helper.Descriptions["aimNormal(e:)"] = "Returns a normalized directional vector perpendicular to the surface pointed at"
E2Helper.Descriptions["frags(e:)"] = "Returns the number of kills the player has made"
E2Helper.Descriptions["deaths(e:)"] = "Returns the number of times the player died"
E2Helper.Descriptions["team(e:)"] = "Returns the team number a player is on"
E2Helper.Descriptions["teamName(n:)"] = "Returns the name of the team associated with the team number"
E2Helper.Descriptions["teamColor(n)"] = "Returns the color of the team associated with the team number"
E2Helper.Descriptions["forward(e:)"] = "Gets the forward direction of the entity 2)"
E2Helper.Descriptions["right(e:)"] = "Gets the right direction of the entity"
E2Helper.Descriptions["up(e:)"] = "Gets the up direction of the entity"
E2Helper.Descriptions["vel(e:)"] = "Gets the velocity of the entity"
E2Helper.Descriptions["velL(e:)"] = "Gets the local velocity of the entity"
E2Helper.Descriptions["boxCenter(e:)"] = "Gets the center of the entity's bounding box, as a local position vector"
E2Helper.Descriptions["boxMax(e:)"] = "Gets the maximum local XYZ of the entity's bounding box (the \"highest\" corner), as a local position vector"
E2Helper.Descriptions["boxMin(e:)"] = "Gets the minimum local XYZ of the entity's bounding box (the \"lowest\" corner), as a local position vector"
E2Helper.Descriptions["boxSize(e:)"] = "Gets the dimensions of the entity's bounding box as a vector (length, width, height)"
E2Helper.Descriptions["toWorld(e:v)"] = "Transforms from a vector local to E to a world vector."
E2Helper.Descriptions["toLocal(e:v)"] = "Transforms from a world vector to a vector local to E."
E2Helper.Descriptions["toWorld(e:a)"] = "Transforms from an angle local to E to a world angle."
E2Helper.Descriptions["toLocal(e:a)"] = "Transforms from a world angle to an angle local to E."
E2Helper.Descriptions["toWorldAxis(e:v)"] = "Transforms an axis local to E to a global axis."
E2Helper.Descriptions["toLocalAxis(e:v)"] = "Transforms a world axis to an axis local to E."
E2Helper.Descriptions["angVel(e:)"] = "Gets the angular velocity of the entity"
E2Helper.Descriptions["angVelVector(e:)"] = "Returns rotation axis, velocity and direction given as the vector's direction, magnitude and sense"
E2Helper.Descriptions["angles(e:)"] = "Gets the pitch, yaw and roll of the entity"
E2Helper.Descriptions["radius(e:)"] = "Gets the size of the object (not precisely, but useful)"
E2Helper.Descriptions["height(e:)"] = "Gets the height of a player or npc"
E2Helper.Descriptions["bearing(e:v)"] = "Gets the bearing from the entity to the vector"
E2Helper.Descriptions["elevation(e:v)"] = "Gets the elevation from the entity to the vector"
E2Helper.Descriptions["heading(e:v)"] = "Gets the elevation and bearing from the entity to the vector"
E2Helper.Descriptions["health(e:)"] = "Gets the health of the entity"
E2Helper.Descriptions["armor(e:)"] = "Gets the armor of the player"
E2Helper.Descriptions["volume(e:)"] = "Gets the volume of the entity"
E2Helper.Descriptions["mass(e:)"] = "Gets the mass of the entity"
E2Helper.Descriptions["timeConnected(e:)"] = "Returns a players time connected to a server"
E2Helper.Descriptions["massCenter(e:)"] = "Gets the Center of Mass of the entity"
E2Helper.Descriptions["massCenterL(e:)"] = "Gets the center of mass as a local vector"
E2Helper.Descriptions["setMass(e:n)"] = "Sets the mass of the entity (between 0.001 and 50,000)"
E2Helper.Descriptions["inertia(e:)"] = "Gets the principal components of the entity's inertia tensor in the form ( Ixx, Iyy, Izz )"
E2Helper.Descriptions["applyForce(e:v)"] = "Applies force to the entity according to the given vector's direction and magnitude"
E2Helper.Descriptions["applyOffsetForce(e:vv)"] = "Applies force to the entity according to the first vector from the location of the second"
E2Helper.Descriptions["applyAngForce(e:a)"] = "Applies torque to the entity according to the given angle"
E2Helper.Descriptions["applyTorque(e:v)"] = "Applies torque according to the given vector, representing the torque axis, magnitude and direction"
E2Helper.Descriptions["isPlayer(e:)"] = "Is the entity a player?"
E2Helper.Descriptions["isOnFire(e:)"] = "Is the entity on fire?"
E2Helper.Descriptions["isWeapon(e:)"] = "Is the entity a weapon?"
E2Helper.Descriptions["isNPC(e:)"] = "Is the entity a NPC?"
E2Helper.Descriptions["isFrozen(e:)"] = "Is the entity frozen?"
E2Helper.Descriptions["isVehicle(e:)"] = "Is the entity a vehicle?"
E2Helper.Descriptions["inVehicle(e:)"] = "Is the player in a vehicle?"
E2Helper.Descriptions["isWorld(e:)"] = "Is the entity the world?"
E2Helper.Descriptions["isOnGround(e:)"] = "Is the player/NPC resting on something?"
E2Helper.Descriptions["isUnderWater(e:)"] = "Is the entity under water?"
E2Helper.Descriptions["isPlayerHolding(e:)"] = "Is the entity being held by a player?"
E2Helper.Descriptions["isAdmin(e:)"] = "Is the player an admin?"
E2Helper.Descriptions["isSuperAdmin(e:)"] = "Is the player a super admin?"
E2Helper.Descriptions["isAlive(e:)"] = "Is the player or NPC alive?"
E2Helper.Descriptions["isCrouch(e:)"] = "Is the player crouching?"
E2Helper.Descriptions["inNoclip(e:)"] = "Is the player in noclip mode?"
E2Helper.Descriptions["friends(e:)"] = "Returns an array of players on the prop protection friends list. "
E2Helper.Descriptions["trusts(e:e2)"] = "Is E2 on the prop protection friends list of E?"
E2Helper.Descriptions["keyAttack1(e:)"] = "Is the player pressing their primary fire key?"
E2Helper.Descriptions["keyAttack2(e:)"] = "Is the player pressing their secondary fire key?"
E2Helper.Descriptions["keyUse(e:)"] = "Is the player pressing their use key?"
E2Helper.Descriptions["driver(e:)"] = "Returns the driver of the vehicle if there is one, nil otherwise"
E2Helper.Descriptions["passenger(e:)"] = "Returns the passenger of the vehicle if there is one, in single seat pods this will return the driver."
E2Helper.Descriptions["vehicle(e:)"] = "Returns the entity of the vehicle that the specified player is in"
E2Helper.Descriptions["ejectPod(e:)"] = "Ejects player in vehicle"
E2Helper.Descriptions["killPod(e:)"] = "Kills player in vehicle"
E2Helper.Descriptions["weapon(e:)"] = "Returns the weapon that player E is currently holding"
E2Helper.Descriptions["clip1(e:)"] = "Returns the amount of ammo in the primary clip of weapon E, -1 if there is no primary clip"
E2Helper.Descriptions["clip2(e:)"] = "Returns the amount of ammo in the secondary clip of weapon E, -1 if there is no secondary clip 1)"
E2Helper.Descriptions["primaryAmmoType(e:)"] = "Returns the type of primary ammo of weapon E as a number in a string"
E2Helper.Descriptions["secondaryAmmoType(e:)"] = "Returns the type of secondary ammo of weapon E as number in a string"
E2Helper.Descriptions["ammoCount(e:s)"] = "Returns the amount of stored ammo of type S on player E, excluding current clip"
E2Helper.Descriptions["tool(e:)"] = "returns the name of the tool the player E is currently holding"
E2Helper.Descriptions["nearestPoint(e:v)"] = "Returns the closest point on the edge of the entity's bounding box to the given vector."
E2Helper.Descriptions["boxCenterW(e:)"] = "Same as using E:toWorld(E:boxCenter()), but since Lua is faster, this is more efficient (also shorter to write)."
E2Helper.Descriptions["aabbMin(e:)"] = "Returns the entity's (min) axis-aligned bounding box."
E2Helper.Descriptions["aabbMax(e:)"] = "Returns the entity's (max) axis-aligned bounding box."
E2Helper.Descriptions["aabbCenter(e:)"] = "Returns the entity's axis-aligned bounding box size."


-- Attachment
E2Helper.Descriptions["lookupAttachment(e:string attachmentname)"] = "Returns Es attachment ID associated with attachmentName"
E2Helper.Descriptions["attachmentPos(e:attachmentid)"] = "Returns Es attachment position associated with attachmentID"
E2Helper.Descriptions["attachmentAng(e:attachmentid)"] = "Returns Es attachment angle associated with attachmentID"
E2Helper.Descriptions["attachmentPos(e:string attachmentname)"] = "Same as E:attachmentPos(E:lookupAttachment(attachmentName))"
E2Helper.Descriptions["attachmentAng(e:string attachmentname)"] = "Same as E:attachmentAng(E:lookupAttachment(attachmentName))"

-- Vector
E2Helper.Descriptions["vec2(nn)"] = "Makes a 2D vector"
E2Helper.Descriptions["vec2()"] = "Same as vec2(0,0)"
E2Helper.Descriptions["vec2(v)"] = "Converts a 3D vector into a 2D vector (the z component is dropped)"
E2Helper.Descriptions["vec2(v4)"] = "Converts a 4D vector into a 2D vector (the z and w components are dropped)"
E2Helper.Descriptions["shift(v2)"] = "Swaps the vector's x,y components "
E2Helper.Descriptions["toAngle(v2:)"] = "Returns the 2D angle of the vector (given in degrees, -180 to 180)"
E2Helper.Descriptions["dehomogenized(v:)"] = "Converts a 2D homogeneous vector (x,y,w) into a 2D cartesian vector"
E2Helper.Descriptions["vec(nnn)"] = "Makes a 3D vector"
E2Helper.Descriptions["vec()"] = "Same as vec(0,0,0)"
E2Helper.Descriptions["vec(v2)"] = "Converts a 2D vector into a 3D vector (the z component is set to 0)"
E2Helper.Descriptions["vec(v2n)"] = "Converts a 2D vector into a 3D vector (the z component is set to the second argument)"
E2Helper.Descriptions["vec(v4)"] = "Converts a 4D vector into a 3D vector (the w component is dropped)"
E2Helper.Descriptions["vec(a)"] = "Changes an angle variable into a vector variable"
E2Helper.Descriptions["randvec()"] = "Returns a uniformly distributed, random, normalized direction vector."
E2Helper.Descriptions["randvec(n1n2)"] = "Returns a random vector with its components between N1 and N2"
E2Helper.Descriptions["randvec(v1v2)"] = "Returns a random vector between V1 and V2"
E2Helper.Descriptions["shiftL(v)"] = "Shifts the vector's components left:  shiftL( x,y,z ) = ( y,z,x )"
E2Helper.Descriptions["shiftR(v)"] = "Shifts the vector's components right:  shiftR( x,y,z ) = ( z,x,y )"
E2Helper.Descriptions["rotate(v:a)"] = "Gets the rotated vector"
E2Helper.Descriptions["rotate(v:nnn)"] = "Gets the rotated vector"
E2Helper.Descriptions["toAngle(v:)"] = "Gets the angles of the vector"
E2Helper.Descriptions["dehomogenized(v4:)"] = "Converts a 3D homogeneous vector (x,y,z,w) into a 3D cartesian vector"
E2Helper.Descriptions["isInWorld(v:)"] = "Returns 1 if the position vector is within the world, 0 if not"
E2Helper.Descriptions["vec4(nnnn)"] = "Makes a 4D vector"
E2Helper.Descriptions["vec4()"] = "Same as vec4(0,0,0,0)"
E2Helper.Descriptions["vec4(v2)"] = "Converts a 2D vector into a 4D vector (the z and w components are set to 0)"
E2Helper.Descriptions["vec4(v2nn)"] = "Converts a 2D vector into a 4D vector (the z and w components are set to the second and third arguments)"
E2Helper.Descriptions["vec4(v2v2)"] = "Creates a 4D vector from two 2D vectors"
E2Helper.Descriptions["vec4(v)"] = "Converts a 3D vector into a 4D vector (the w component is set to 0)"
E2Helper.Descriptions["vec4(vn)"] = "Converts a 3D vector into a 4D vector (the w component is set to the second argument)"
E2Helper.Descriptions["shiftL(v4)"] = "Shifts the vector's components left:  shiftL( x,y,z,w ) = ( y,z,w,x )"
E2Helper.Descriptions["shiftR(v4)"] = "Shifts the vector's components right:  shiftR( x,y,z,w ) = ( w,x,y,z )"
E2Helper.Descriptions["ceil(v)"] = "Rounds XYZ up to the nearest integer"
E2Helper.Descriptions["ceil(vn)"] = "Rounds XYZ up to argument 2's decimal precision"
E2Helper.Descriptions["floor(v)"] = "Rounds XYZ down to the nearest integer"
E2Helper.Descriptions["floor(vn)"] = "Rounds XYZ down to argument 2's decimal precision"
E2Helper.Descriptions["round(v)"] = "Rounds XYZ to the nearest integer"
E2Helper.Descriptions["round(vn)"] = "Rounds XYZ to argument 2's decimal precision"
E2Helper.Descriptions["mod(vn)"] = "Returns the remainder after XYZ have been divided by argument 2"
E2Helper.Descriptions["mod(vv)"] = "Returns the remainder after the components of vector 1 have been divided by the components of vector 2"
E2Helper.Descriptions["clamp(vvv)"] = "Clamps vector 1's XYZ between the XYZ of vector 2(min) and vector 3(max)"
E2Helper.Descriptions["clamp(vnn)"] = "Returns a vector in the same direction as vector 1, with length clamped between argument 2(min) and argument 3(max)"
E2Helper.Descriptions["min(vv)"] = "Returns the vector with the smallest length"
E2Helper.Descriptions["max(vv)"] = "Returns the vector with the greatest length"
E2Helper.Descriptions["minVec(vv)"] = "Returns a vector combining the lowest value components of V1 and V2"
E2Helper.Descriptions["maxVec(vv)"] = "Returns the vector combining the highest value components of V1 and V2"
E2Helper.Descriptions["mix(vvn)"] = "Combines vector 1's XYZ with vector 2's XYZ by a proportion given by argument 3 (between 0 and 1)"
E2Helper.Descriptions["positive(v)"] = "Returns a vector containing the positive value of each vector component, equivalent to abs(N)"
E2Helper.Descriptions["inrange(vvminvmax)"] = "Returns 1 if each component of V is between (or is equal to) the components of Vmin and Vmax"
E2Helper.Descriptions["length(v:)"] = "Gets the length of the vector"
E2Helper.Descriptions["length2(v:)"] = "Gets the squared length of the vector"
E2Helper.Descriptions["distance(v:v)"] = "Gets the distance between vectors"
E2Helper.Descriptions["distance2(v:v)"] = "Gets the squared distance between vectors"
E2Helper.Descriptions["normalized(v:)"] = "Gets the normalized vector"
E2Helper.Descriptions["dot(v:v)"] = "Gets the vector dot (scalar) product"
E2Helper.Descriptions["x(v:)"] = "Gets the x component of the vector"
E2Helper.Descriptions["y(v:)"] = "Gets the y component of the vector"
E2Helper.Descriptions["z(v:)"] = "Gets the z component of the vector"
E2Helper.Descriptions["w(v:)"] = "Gets the w component of the vector"
E2Helper.Descriptions["setX(v:n)"] = "Returns a copy of the vector with X replaced (use as Vec = Vec:setX(...))"
E2Helper.Descriptions["setY(v:n)"] = "Returns a copy of the vector with Y replaced (use as Vec = Vec:setY(...))"
E2Helper.Descriptions["setZ(v:n)"] = "Returns a copy of the vector with Z replaced (use as Vec = Vec:setZ(...))"
E2Helper.Descriptions["setW(v:n)"] = "Returns a copy of the vector with W replaced (use as Vec = Vec:setW(...))"
E2Helper.Descriptions["toString(v:)"] = "Gets the vector nicely formatted as a string \"[X,Y,Z]\""
E2Helper.Descriptions["toWorld(vava)"] = "Converts a local position/angle to a world position/angle and returns the position"
E2Helper.Descriptions["toWorldAng(vava)"] = "Converts a local position/angle to a world position/angle and returns the angle"
E2Helper.Descriptions["toWorldPosAng(vava)"] = "Converts a local position/angle to a world position/angle and returns both in an array"
E2Helper.Descriptions["toLocal(vava)"] = "Converts a world position/angle to a local position/angle and returns the position"
E2Helper.Descriptions["toLocalAng(vava)"] = "Converts a world position/angle to a local position/angle and returns the angle"
E2Helper.Descriptions["toLocalPosAng(vava)"] = "Converts a world position/angle to a local position/angle and returns both in an array"

-- Matrix
E2Helper.Descriptions["identity2()"] = "Creates a 2x2 identity matrix"
E2Helper.Descriptions["matrix2()"] = "Creates a 2x2 zero matrix"
E2Helper.Descriptions["matrix2(nnnn)"] = "Creates a matrix with values in order (i.j) of: (1,1), (1,2), (2,1), (2,2)"
E2Helper.Descriptions["matrix2(v2v2)"] = "Creates a matrix with vectors by columns"
E2Helper.Descriptions["matrix2(m)"] = "Converts a 3x3 matrix into a 2x2 matrix - all (i,3) and (3,j) are omitted"
E2Helper.Descriptions["matrix2(m4)"] = "Converts a 4x4 matrix into a 2x2 matrix - all (i,3), (i,4), (3,j) and (4,j) are omitted"
E2Helper.Descriptions["swapRows(m2:)"] = "Swaps rows"
E2Helper.Descriptions["swapColumns(m2:)"] = "Swaps columns"
E2Helper.Descriptions["setRow(m2:nnn)"] = "Sets the values of a row. The first argument given specifies the row(j), the following arguments are the values 1j, 2j"
E2Helper.Descriptions["setRow(m2:nv2)"] = "Sets the values of a row. The first argument given specifies the row, the vector contains the values to set"
E2Helper.Descriptions["setColumn(m2:nnn)"] = "Sets the values of a column. The first argument given specifies the column(i), the following arguments are the values i1, i2"
E2Helper.Descriptions["setColumn(m2:nv2)"] = "Sets the values of a column. The first argument given specifies the column, the vector contains the values to set"
E2Helper.Descriptions["identity2()"] = "Creates a 2x2 identity matrix"
E2Helper.Descriptions["matrix2()"] = "Creates a 2x2 zero matrix"
E2Helper.Descriptions["matrix2(nnnn)"] = "Creates a matrix with values in order (i.j) of: (1,1), (1,2), (2,1), (2,2)"
E2Helper.Descriptions["matrix2(v2v2)"] = "Creates a matrix with vectors by columns"
E2Helper.Descriptions["matrix2(m)"] = "Converts a 3x3 matrix into a 2x2 matrix - all (i,3) and (3,j) are omitted"
E2Helper.Descriptions["matrix2(m4)"] = "Converts a 4x4 matrix into a 2x2 matrix - all (i,3), (i,4), (3,j) and (4,j) are omitted"
E2Helper.Descriptions["swapRows(m2:)"] = "Swaps rows"
E2Helper.Descriptions["swapColumns(m2:)"] = "Swaps columns"
E2Helper.Descriptions["setRow(m2:nnn)"] = "Sets the values of a row. The first argument given specifies the row(j), the following arguments are the values 1j, 2j"
E2Helper.Descriptions["setRow(m2:nv2)"] = "Sets the values of a row. The first argument given specifies the row, the vector contains the values to set"
E2Helper.Descriptions["setColumn(m2:nnn)"] = "Sets the values of a column. The first argument given specifies the column(i), the following arguments are the values i1, i2"
E2Helper.Descriptions["setColumn(m2:nv2)"] = "Sets the values of a column. The first argument given specifies the column, the vector contains the values to set"
E2Helper.Descriptions["identity()"] = "Creates a 3x3 identity matrix"
E2Helper.Descriptions["matrix()"] = "Creates a 3x3 zero matrix"
E2Helper.Descriptions["matrix(n1n2... n9)"] = "Creates a matrix with 9 values in the following order (i.j): (1,1), (1,2), (1,3), (2,1) etc."
E2Helper.Descriptions["matrix(vvv)"] = "Creates a matrix with vectors by columns"
E2Helper.Descriptions["matrix(m2)"] = "Converts a 2x2 matrix into a 3x3 matrix - all (i,3) and (3,j) are filled with 0's"
E2Helper.Descriptions["matrix(m4)"] = "Converts a 4x4 matrix into a 3x3 matrix - all (i,4) and (4,j) are omitted"
E2Helper.Descriptions["swapRows(m:nn)"] = "Swaps the two rows specified"
E2Helper.Descriptions["swapColumns(m:nn)"] = "Swaps the two columns specified"
E2Helper.Descriptions["setRow(m:nnnn)"] = "Sets the values of a row. The first argument given specifies the row(j), the following arguments are the values 1j, 2j, 3j"
E2Helper.Descriptions["setRow(m:nv)"] = "Sets the values of a row. The first argument given specifies the row, the vector contains the values to set"
E2Helper.Descriptions["setColumn(m:nnnn)"] = "Sets the values of a column. The first argument given specifies the column(i), the following arguments are the values i1, i2, i3"
E2Helper.Descriptions["setColumn(m:nv)"] = "Sets the values of a column. The first argument given specifies the column, the vector contains the values to set"
E2Helper.Descriptions["setDiagonal(m:nnn)"] = "Sets the elements of the leading diagonal"
E2Helper.Descriptions["setDiagonal(m:v)"] = "Sets the elements of the leading diagonal from the components of a vector"
E2Helper.Descriptions["matrix(e)"] = "Creates a reference frame matrix from an entity's local direction vectors by columns in the order ( x, y, z )"
E2Helper.Descriptions["matrix(a)"] = "Returns a 3x3 reference frame matrix as described by the angle A. Multiplying by this matrix will be the same as rotating by the given angle."
E2Helper.Descriptions["x(m:)"] = "Returns the local x direction vector from a 3x3 coordinate reference frame matrix ( same as M:column(1) )"
E2Helper.Descriptions["y(m:)"] = "Returns the local y direction vector from a 3x3 coordinate reference frame matrix ( same as M:column(2) )"
E2Helper.Descriptions["z(m:)"] = "Returns the local z direction vector from a 3x3 coordinate reference frame matrix ( same as M:column(3) )"
E2Helper.Descriptions["mRotation(vn)"] = "Creates a 3x3 rotation matrix, where the vector is the axis of rotation, and the number is the angle (anti-clockwise) in degrees. Example*: to rotate a vector (7,8,9) by 50 degrees about the axis (1,1,0), you would write V = mRotation(vec(1,1,0), 50) * vec(7,8,9)"
E2Helper.Descriptions["identity4()"] = "Creates a 4x4 identity matrix"
E2Helper.Descriptions["matrix4()"] = "Creates a 4x4 zero matrix"
E2Helper.Descriptions["matrix4(n1n2... n16)"] = "Creates a matrix with 16 values in the following order (i.j): (1,1), (1,2), (1,3), (1,4), (2,1) etc."
E2Helper.Descriptions["matrix4(v4v4v4v4)"] = "Creates a matrix with vectors by columns"
E2Helper.Descriptions["matrix4(m2)"] = "Converts a 2x2 matrix into a 4x4 matrix - all (i,3), (i,4), (3,j) and (4,j) are filled with 0's"
E2Helper.Descriptions["matrix4(m2m2m2m2)"] = "Constructs a 4x4 matrix from four 2x2 matrices"
E2Helper.Descriptions["matrix4(m)"] = "Converts a 3x3 matrix into a 4x4 matrix - all (i,4) and (4,j) are filled with 0's"
E2Helper.Descriptions["swapRows(m4:nn)"] = "Swaps the two rows specified"
E2Helper.Descriptions["swapColumns(m4:nn)"] = "Swaps the two columns specified"
E2Helper.Descriptions["setRow(m4:nnnnn)"] = "Sets the values of a row. The first argument given specifies the row(j), the following arguments are the values 1j, 2j, 3j, 4j"
E2Helper.Descriptions["setRow(m4:nv4)"] = "Sets the values of a row. The first argument given specifies the row, the vector contains the values to set"
E2Helper.Descriptions["setColumn(m4:nnnnn)"] = "Sets the values of a column. The first argument given specifies the column(i), the following arguments are the values i1, i2, i3, i4"
E2Helper.Descriptions["setColumn(m4:nv4)"] = "Sets the values of a column. The first argument given specifies the column, the vector contains the values to set"
E2Helper.Descriptions["setDiagonal(m4:nnnn)"] = "Sets the elements of the leading diagonal"
E2Helper.Descriptions["setDiagonal(m4:v4)"] = "Sets the elements of the leading diagonal from the components of a vector"
E2Helper.Descriptions["matrix4(e)"] = "Creates a 4x4 reference frame matrix from an entity's local direction vectors by columns in the order (x, y, z, pos), with the bottom row (0,0,0,1)"
E2Helper.Descriptions["matrix4(a)"] = "Returns a 4x4 reference frame matrix as described by the angle A. Multiplying by this matrix will be the same as rotating by the given angle."
E2Helper.Descriptions["matrix4(av)"] = "Returns a 4x4 reference frame matrix as described by the angle A and the position V. Multiplying by this matrix will be the same as rotating by the given angle and offsetting by the given vector."
E2Helper.Descriptions["x(m4:)"] = "Returns the local x direction vector from a 4x4 coordinate reference frame matrix"
E2Helper.Descriptions["y(m4:)"] = "Returns the local y direction vector from a 4x4 coordinate reference frame matrix"
E2Helper.Descriptions["z(m4:)"] = "Returns the local z direction vector from a 4x4 coordinate reference frame matrix"
E2Helper.Descriptions["pos(m4:)"] = "Returns the position vector from a 4x4 coordinate reference frame matrix"
E2Helper.Descriptions["inverseA(m4)"] = "Finds the matrix inverse of a standard 4x4 affine transformation matrix ( the type created by matrix4(E) ). This should only be used on matrices with a particular format, where the top left 3x3 specifies rotation, the rightmost 3-column specifies translation, and the bottom row is (0,0,0,1)"
E2Helper.Descriptions["row(m:n)"] = "Returns the row as a vector"
E2Helper.Descriptions["column(m:n)"] = "Returns the column as a vector"
E2Helper.Descriptions["element(m:nn)"] = "Returns the element with indices (i,j)"
E2Helper.Descriptions["setElement(m:nnn)"] = "Sets an element's value. The first two arguments specify the indices (i,j), the third argument is the value to set it to"
E2Helper.Descriptions["swapElements(m:nnnn)"] = "Swaps two elements, specified by indices ( i1, j1, i2, j2 )"
E2Helper.Descriptions["diagonal(m)"] = "Returns a vector comprising the elements along the leading diagonal"
E2Helper.Descriptions["trace(m)"] = "Returns the trace of a matrix"
E2Helper.Descriptions["det(m)"] = "Returns the determinant of a matrix (Does not work for 4x4 matrices)"
E2Helper.Descriptions["transpose(m)"] = "Returns the transpose of a matrix"
E2Helper.Descriptions["adj(m)"] = "Returns the adjugate of a matrix (Does not work for 4x4 matrices)"

-- Angle
E2Helper.Descriptions["ang(nnn)"] = "Makes an angle"
E2Helper.Descriptions["ang()"] = "Same as ang(0,0,0)"
E2Helper.Descriptions["ang(v)"] = "Changes a vector variable into an angle variable"
E2Helper.Descriptions["ceil(a)"] = "Rounds PYR up to the nearest integer"
E2Helper.Descriptions["ceil(an)"] = "Rounds PYR up to argument 2's decimal precision"
E2Helper.Descriptions["floor(a)"] = "Rounds PYR down to the nearest integer"
E2Helper.Descriptions["floor(an)"] = "Rounds PYR down to argument 2's decimal precision"
E2Helper.Descriptions["round(a)"] = "Rounds PYR to the nearest integer"
E2Helper.Descriptions["round(an)"] = "Rounds PYR to argument 2's decimal precision"
E2Helper.Descriptions["mod(an)"] = "Returns the remainder after PYR have been divided by argument 2"
E2Helper.Descriptions["mod(aa)"] = "Returns the remainder after the components of angle 1 have been divided by the components of angle 2"
E2Helper.Descriptions["clamp(aaa)"] = "Clamps angle 1's PYR between the PYR of angle 2(min) and angle 3(max)"
E2Helper.Descriptions["clamp(ann)"] = "Clamps angle 1's PYR between argument 2(min) and argument 3(max)"
E2Helper.Descriptions["mix(aan)"] = "Combines angle 1's PYR with angle 2's PYR by a proportion given by argument 3 (between 0 and 1)"
E2Helper.Descriptions["shiftL(a)"] = "Shifts the angle's components left:  shiftL( p,y,r ) = ( y,r,p )"
E2Helper.Descriptions["shiftR(a)"] = "Shifts the angle's components right:  shiftR( p,y,r ) = ( r,p,y )"
E2Helper.Descriptions["inrange(aaminamax)"] = "Returns 1 if each component of A is between (or is equal to) the components of Amin and Amax"
E2Helper.Descriptions["angnorm(a)"] = "Gets the normalized angle of an angle"
E2Helper.Descriptions["angnorm(n)"] = "Gets the normalized angle of a number"
E2Helper.Descriptions["pitch(a:)"] = "Gets the pitch of the angle"
E2Helper.Descriptions["yaw(a:)"] = "Gets the yaw of the angle"
E2Helper.Descriptions["roll(a:)"] = "Gets the roll of the angle"
E2Helper.Descriptions["setPitch(a:n)"] = "Returns a copy of the angle with Pitch replaced (use as Ang = Ang:setPitch(...)) "
E2Helper.Descriptions["setYaw(a:n)"] = "Returns a copy of the angle with Yaw replaced (use as Ang = Ang:setYaw(...)) "
E2Helper.Descriptions["setRoll(a:n)"] = "Returns a copy of the angle with Roll replaced (use as Ang = Ang:setRoll(...)) "
E2Helper.Descriptions["toString(a:)"] = "Gets the angle nicely formatted as a string \"[P,Y,R]\""

-- Entity
E2Helper.Descriptions["forward(a:)"] = "Gets the forward vector of the angle."
E2Helper.Descriptions["right(a:)"] = "Gets the right vector of the angle."
E2Helper.Descriptions["up(a:)"] = "Gets the up vector of the angle."
E2Helper.Descriptions["rotateAroundAxis(a:vn)"] = "Returns the angle A rotated around vector V by N degrees."
E2Helper.Descriptions["bone(e:n)"] = "Returns Es Nth bone"
E2Helper.Descriptions["bones(e:)"] = "Returns an array containing all of Es bones. This array's first element has the index 0!"
E2Helper.Descriptions["boneCount(e:)"] = "Returns Es number of bones"
E2Helper.Descriptions["nobone()"] = "Returns an invalid bone"
E2Helper.Descriptions["aimBone(e:)"] = "Returns the bone the player is currently aiming at"
E2Helper.Descriptions["entity(b:)"] = "Returns the entity B belongs to"
E2Helper.Descriptions["index(b:)"] = "Returns Bs index in the entity it belongs to. Returns -1 if the bone is invalid or an error occured"
E2Helper.Descriptions["pos(b:)"] = "Returns Bs position"
E2Helper.Descriptions["forward(b:)"] = "Returns a vector describing Bs forward direction"
E2Helper.Descriptions["right(b:)"] = "Returns a vector describing Bs right direction"
E2Helper.Descriptions["up(b:)"] = "Returns a vector describing Bs up direction"
E2Helper.Descriptions["vel(b:)"] = "Returns Bs velocity"
E2Helper.Descriptions["velL(b:)"] = "Returns Bs velocity in local coordinates"
E2Helper.Descriptions["toWorld(b:v)"] = "Transforms V from local coordinates (as seen from B) to world coordinates"
E2Helper.Descriptions["toLocal(b:v)"] = "Transforms V from world coordinates to local coordinates (as seen from B)"
E2Helper.Descriptions["angVel(b:)"] = "Returns Bs angular velocity"
E2Helper.Descriptions["angles(b:)"] = "Returns Bs pitch, yaw and roll angles"
E2Helper.Descriptions["bearing(b:v)"] = "Returns the bearing (yaw) from B to V"
E2Helper.Descriptions["elevation(b:v)"] = "Returns the elevation (pitch) from B to V"
E2Helper.Descriptions["mass(b:)"] = "Returns Bs mass"
E2Helper.Descriptions["massCenter(b:)"] = "Returns Bs Center of Mass"
E2Helper.Descriptions["massCenterL(b:)"] = "Returns Bs Center of Mass in local coordinates"
E2Helper.Descriptions["inertia(b:)"] = "Gets the principal components of Bs inertia tensor in the form vec(Ixx, Iyy, Izz)"
E2Helper.Descriptions["isFrozen(b:)"] = "Returns 1 if B is frozen, 0 otherwise"

-- Wirelink
E2Helper.Descriptions["isHiSpeed(xwl:)"] = "Returns true if the linked component is high-speed capable."
E2Helper.Descriptions["entity(xwl:)"] = "Returns the entity of the linked component."
E2Helper.Descriptions["hasInput(xwl:s)"] = "Returns true if the linked component has an input of the specified name."
E2Helper.Descriptions["hasOutput(xwl:s)"] = "Returns true if the linked component has an output of the specified name."
E2Helper.Descriptions["xyz(xwl:)"] = "Retrieves the X/Y/Z as the corresponding values in the vector."
E2Helper.Descriptions["writeString(xwl:ns)"] = "Writes a null-terminated string to the given address. Returns the next free address or 0 on failure."
E2Helper.Descriptions["readString(xwl:n)"] = "Reads a null-terminated string from the given address. Returns an empty string on failure."
E2Helper.Descriptions["writeArray(xwl:nr)"] = "Writes an array's elements into a piece of memory. Strings and sub-tables (angles, vectors, matrices) are written as pointers to the actual data. Strings are written null-terminated."
E2Helper.Descriptions["inputs(xwl:)"] = "Returns an array of all the inputs that XWL has without their types. Returns an empty array if it has none"
E2Helper.Descriptions["outputs(xwl:)"] = "Returns an array of all the outputs that XWL has without their types. Returns an empty array if it has none"
E2Helper.Descriptions["inputType(xwl:s)"] = "Returns the type of input that S is in lowercase. ( \"NORMAL\"  is changed to \"number\" )"
E2Helper.Descriptions["outputType(xwl:s)"] = "Returns the type of output that S is in lowercase. ( \"NORMAL\"  is changed to \"number\" )"

-- Quaternions
E2Helper.Descriptions["comp()"] = "Returns complex zero"
E2Helper.Descriptions["comp(n)"] = "Converts a real number to complex (returns complex number with real part N and imaginary part 0)"
E2Helper.Descriptions["comp(nn2)"] = "Returns N+N2*i"
E2Helper.Descriptions["i()"] = "Returns the imaginary unit i"
E2Helper.Descriptions["i(n)"] = "Returns N*i"
E2Helper.Descriptions["abs(c)"] = "Returns the absolute value of C"
E2Helper.Descriptions["arg(c)"] = "Returns the argument of C"
E2Helper.Descriptions["conj(c)"] = "Returns the conjugate of C"
E2Helper.Descriptions["real(c)"] = "Returns the real part of C"
E2Helper.Descriptions["imag(c)"] = "Returns the imaginary part of C"
E2Helper.Descriptions["exp(c)"] = "Raises Euler's constant e to the power of C"
E2Helper.Descriptions["log(c)"] = "Calculates the natural logarithm of C"
E2Helper.Descriptions["log(cc2)"] = "Calculates the logarithm of C2 to a complex base C"
E2Helper.Descriptions["log(nc)"] = "Calculates the logarithm of C to a real base N"
E2Helper.Descriptions["log2(c)"] = "Calculates the logarithm of C to base 2"
E2Helper.Descriptions["log10(c)"] = "Calculates the logarithm of C to base 10"
E2Helper.Descriptions["sqrt(c)"] = "Calculates the square root of C"
E2Helper.Descriptions["csqrt(n)"] = "Calculates the complex square root of the real number N"
E2Helper.Descriptions["sin(c)"] = "Calculates the sine of C"
E2Helper.Descriptions["cos(c)"] = "Calculates the cosine of C"
E2Helper.Descriptions["tan(c)"] = "Calculates the tangent of C"
E2Helper.Descriptions["cot(c)"] = "Calculates the cotangent of C"
E2Helper.Descriptions["sec(c)"] = "Calculates the secant of C"
E2Helper.Descriptions["csc(c)"] = "Calculates the cosecant of C"
E2Helper.Descriptions["asin(c)"] = "Calculates the inverse sine of C"
E2Helper.Descriptions["acos(c)"] = "Calculates the inverse cosine of C"
E2Helper.Descriptions["atan(c)"] = "Calculates the inverse tangent of C"
E2Helper.Descriptions["sinh(c)"] = "Calculates the hyperbolic sine of C"
E2Helper.Descriptions["cosh(c)"] = "Calculates the hyperbolic cosine of C"
E2Helper.Descriptions["tanh(c)"] = "Calculates the hyperbolic tangent of C"
E2Helper.Descriptions["coth(c)"] = "Calculates the hyperbolic cotangent of C"
E2Helper.Descriptions["sech(c)"] = "Calculates the hyperbolic secant of C"
E2Helper.Descriptions["csch(c)"] = "Calculates the hyperbolic cosecant of C"
E2Helper.Descriptions["toString(c)"] = "Formats C as a string."
E2Helper.Descriptions["toString(c:)"] = "The same as toString(C)."
E2Helper.Descriptions["quat()"] = "Creates a zero quaternion"
E2Helper.Descriptions["quat(n)"] = "Creates a quaternion with real part equal to N"
E2Helper.Descriptions["quat(c)"] = "Creates a quaternion with real and \"i\" parts equal to C"
E2Helper.Descriptions["quat(v)"] = "Converts a vector to a quaternion (returns V.x*i + V.y*j + V.z*k)"
E2Helper.Descriptions["quat(nn2n3n4)"] = "Returns N+N2i+N3j+N4k"
E2Helper.Descriptions["quat(a)"] = "Converts A to a quaternion"
E2Helper.Descriptions["quat(vv2)"] = "Creates a quaternion given forward (V) and up (V2) vectors"
E2Helper.Descriptions["quat(e)"] = "Converts angle of E to a quaternion"
E2Helper.Descriptions["qi()"] = "Returns quaternion i"
E2Helper.Descriptions["qi(n)"] = "Returns quaternion N*i"
E2Helper.Descriptions["qj()"] = "Returns j"
E2Helper.Descriptions["qj(n)"] = "Returns N*j"
E2Helper.Descriptions["qk()"] = "Returns k"
E2Helper.Descriptions["qk(n)"] = "Returns N*k"
E2Helper.Descriptions["abs(q)"] = "Returns absolute value of Q"
E2Helper.Descriptions["conj(q)"] = "Returns the conjugate of Q"
E2Helper.Descriptions["inv(q)"] = "Returns the inverse of Q"
E2Helper.Descriptions["real(q:)"] = "Returns the real component of the quaternion"
E2Helper.Descriptions["i(q:)"] = "Returns the i component of the quaternion"
E2Helper.Descriptions["j(q:)"] = "Returns the j component of the quaternion"
E2Helper.Descriptions["k(q:)"] = "Returns the k component of the quaternion"
E2Helper.Descriptions["exp(q)"] = "Raises Euler's constant e to the power Q"
E2Helper.Descriptions["log(q)"] = "Calculates natural logarithm of Q"
E2Helper.Descriptions["qMod(q)"] = "Changes quaternion Q so that the represented rotation is by an angle between 0 and 180 degrees (by coder0xff)"
E2Helper.Descriptions["slerp(qq2n)"] = "Performs spherical linear interpolation between Q and Q2. Returns Q for N=0, Q2 for N=1"
E2Helper.Descriptions["forward(q:)"] = "Returns vector pointing forward for Q"
E2Helper.Descriptions["right(q:)"] = "Returns vector pointing right for Q"
E2Helper.Descriptions["up(q:)"] = "Returns vector pointing up for Q"
E2Helper.Descriptions["qRotation(vn)"] = "Returns quaternion for rotation about axis V by angle N"
E2Helper.Descriptions["qRotation(v)"] = "Construct a quaternion from the rotation vector V. Vector direction is axis of rotation, magnitude is angle in degress (by coder0xff)"
E2Helper.Descriptions["rotationAngle(q)"] = "Returns the angle of rotation in degrees (by coder0xff)"
E2Helper.Descriptions["rotationAxis(q)"] = "Returns the axis of rotation (by coder0xff)"
E2Helper.Descriptions["rotationVector(q)"] = "Returns the rotation vector - rotation axis where magnitude is the angle of rotation in degress (by coder0xff)"
E2Helper.Descriptions["vec(q)"] = "Converts Q to a vector by dropping the real component"
E2Helper.Descriptions["matrix(q)"] = "Converts Q to a transformation matrix"
E2Helper.Descriptions["toAngle(q:)"] = "Returns angle represented by Q"
E2Helper.Descriptions["toString(q)"] = "Formats Q as a string."

-- Selfaware
E2Helper.Descriptions["first()"] = "Returns 1 if the expression was spawned or reset"
E2Helper.Descriptions["duped()"] = "Returns 1 if the expression was duplicated"
E2Helper.Descriptions["dupefinished()"] = "Returns 1 when the contraption has finished duping. (Only triggers on Adv Duplicator, not the normal duplicator)"
E2Helper.Descriptions["inputClk()"] = "Returns 1 if the expression was triggered by an input"
E2Helper.Descriptions["last()"] = "Returns 1 if it is being called on the last execution of the expression gate before it is removed or reset. This execution must be requested with the runOnLast(1) command."
E2Helper.Descriptions["removing()"] = "Returns 1 if this is the last() execution and caused by the entity being removed."
E2Helper.Descriptions["ops()"] = "Returns how many ops are used every execution on average"
E2Helper.Descriptions["opcounter()"] = "Returns how many ops have been used so far in this execution plus the amount of hard quota used"
E2Helper.Descriptions["minquota()"] = "The ops left before soft quota is used up"
E2Helper.Descriptions["maxquota()"] = "The ops left before hard quota is exceeded and the expression shuts down"
E2Helper.Descriptions["perf()"] = "If used as a while loop condition, stabilizes the expression around  hardquota used."
E2Helper.Descriptions["entity()"] = "Gets the entity of the expression"
E2Helper.Descriptions["getName(e)"] = "Get the name of another E2."
E2Helper.Descriptions["setName()"] = "Set the name of the E2."

E2Helper.Descriptions["concmd(s)"] = "Takes a string and executes it in console. Returns 1 if it succeeded and 0 if it failed.The client must enable this in the console with \"wire_expression2_concmd 1\". \"wire_expression2_concmd_whitelist\" allows you to choose which commands can be used.[http://www.wiremod.com/forum/151800-post12.html]"
E2Helper.Descriptions["select(n*...)"] = "Returns the Nth value given after the index, *'s zero element otherwise. If you mix types, the behaviour is undefined."

-- Driver hints
E2Helper.Descriptions["printDriver(e:s)"] = "Posts a string to the chat of Es driver. Returns 1 if the text was printed, 0 if not."
E2Helper.Descriptions["hintDriver(e:sn)"] = "Displays a hint popup to the driver of vehicle E, with message S for N seconds (N being clamped between 0.7 and 7). Same return value as printDriver."
E2Helper.Descriptions["printDriver(e:ns)"] = "Same as EE:printDriver(S), but can make the text show up in different places. N can be one of the following: _HUD_PRINTCENTER, _HUD_PRINTCONSOLE, _HUD_PRINTNOTIFY, _HUD_PRINTTALK."

-- Time
E2Helper.Descriptions["tickClk()"] = "Returns 1 if the current execution was caused by \"runOnTick\""
E2Helper.Descriptions["curtime()"] = "Returns the current game time since server-start in seconds*"
E2Helper.Descriptions["realtime()"] = "Returns the current real time since server-start in seconds*"
E2Helper.Descriptions["clk(s)"] = "Returns 1 if the current execution was caused by the inserted name"

-- Unit conversion
E2Helper.Descriptions["toUnit(sn)"] = "Converts default garrysmod units to specified units"
E2Helper.Descriptions["fromUnit(sn)"] = "Converts specified units to default garrysmod units"
E2Helper.Descriptions["convertUnit(ssn)"] = "Converts between two units"

-- Server information
E2Helper.Descriptions["map()"] = "Returns the current map name"
E2Helper.Descriptions["hostname()"] = "Returns the Name of the server"
E2Helper.Descriptions["isLan()"] = "Returns 1 if lan mode is enabled"
E2Helper.Descriptions["gamemode()"] = "Returns the name of the current gamemode"
E2Helper.Descriptions["gravity()"] = "Returns gravity"
E2Helper.Descriptions["ping(e:)"] = "Returns the latency for player E"
E2Helper.Descriptions["isSinglePlayer()"] = "Returns 1 if singleplayer, 0 if multiplayer"
E2Helper.Descriptions["isDedicated()"] = "Returns 1 if server is dedicated, 0 if listen"
E2Helper.Descriptions["numPlayers()"] = "Returns the number of players currently in the server"
E2Helper.Descriptions["maxPlayers()"] = "Returns the max number of players allowed in the server"
E2Helper.Descriptions["maxOfType(s)"] = "Returns the maximum allowed of a certain type of entity, i.e. maxOfType(\"wire_thrusters\").  Returns 0 if you enter an invalid parameter."
E2Helper.Descriptions["playerDamage()"] = "Returns 1 if player vs player damage is enabled on the server"
E2Helper.Descriptions["convar(s)"] = "Give a console command such as \"name\" and it returns the set value"
E2Helper.Descriptions["convarnum(s)"] = "Give a console command such as \"sbox_godmode\" and it returns the set value"
E2Helper.Descriptions["time(s)"] = "Returns numerical time/date info from the server. Possible arguments: \"year\", \"month\", \"day\", \"hour\", \"min\", \"sec\", \"wday\" (weekday, Sunday is 1), \"yday\" (day of the year), and \"isdst\" (daylight saving flag 0/1)"

-- Constraints
E2Helper.Descriptions["getConstraints(e:)"] = "Returns an array with all entities directly or indirectly constrained to E, except E itself."
E2Helper.Descriptions["hasConstraints(e:)"] = "Returns the number of the constraints E has"
E2Helper.Descriptions["hasConstraints(e:s)"] = "Returns the number of the constraints E has with the given constraint type (see the types list below)"
E2Helper.Descriptions["isConstrained(e:)"] = "Returns 1 if E has constraints, 0 if not"
E2Helper.Descriptions["isWeldedTo(e:)"] = "Returns the first entity E was welded to"
E2Helper.Descriptions["isWeldedTo(e:n)"] = "Returns the Nth entity E was welded to"
E2Helper.Descriptions["isConstrainedTo(e:)"] = "Returns the first entity E was constrained to"
E2Helper.Descriptions["isConstrainedTo(e:n)"] = "Returns the Nth entity E was constrained to"
E2Helper.Descriptions["isConstrainedTo(e:s)"] = "Returns the first entity E was constrained to with the given constraint type (see the types list below)"
E2Helper.Descriptions["isConstrainedTo(e:s n)"] = "Returns the Nth entity E was constrained to with the given constraint type (see the types list below)"
E2Helper.Descriptions["parent(e:)"] = "Returns the entity E is parented to."
E2Helper.Descriptions["parentBone(e:)"] = "Returns the bone E is parented to."

-- Chat
E2Helper.Descriptions["chatClk()"] = "Returns 1 if the chip is being executed because of a chat event. Returns 0 otherwise."
E2Helper.Descriptions["chatClk(e)"] = "Returns 1 if the chip is being executed because of a chat event by player E. Returns 0 otherwise."
E2Helper.Descriptions["lastSpoke()"] = "Returns the last player to speak."
E2Helper.Descriptions["lastSaid()"] = "Returns the last message in the chat log."
E2Helper.Descriptions["lastSaidWhen()"] = "Returns the time the last message was sent."
E2Helper.Descriptions["lastSaidTeam()"] = "Returns 1 if the last message was sent in the team chat, 0 otherwise."
E2Helper.Descriptions["lastSaid(e:)"] = "Returns what the player E last said."
E2Helper.Descriptions["lastSaidWhen(e:)"] = "Returns when the given player last said something."
E2Helper.Descriptions["lastSaidTeam(e:)"] = "Returns 1 if the last message was sent in the team chat, 0 otherwise."

-- Color
E2Helper.Descriptions["getColor(e:)"] = "Returns the color of an entity as a vector (R,G,B)"
E2Helper.Descriptions["getColor4(e:)"] = "Returns the color of an entity as a 4D vector (R,G,B,A)"
E2Helper.Descriptions["getAlpha(e:)"] = "Returns the alpha of an entity"
E2Helper.Descriptions["getMaterial(e:)"] = "Returns the material of an entity"
E2Helper.Descriptions["getSkin(e:)"] = "Gets Es current skin number."
E2Helper.Descriptions["getSkinCount(e:)"] = "Gets Es number of skins."
E2Helper.Descriptions["hsv2rgb(v)"] = "Converts V from the [http://en.wikipedia.org/wiki/HSV_color_space HSV color space] to the [http://en.wikipedia.org/wiki/RGB_color_space RGB color space]"
E2Helper.Descriptions["rgb2hsv(v)"] = "Converts V from the [http://en.wikipedia.org/wiki/RGB_color_space RGB color space] to the [http://en.wikipedia.org/wiki/HSV_color_space HSV color space]"
E2Helper.Descriptions["rgb2digi(vn)"] = "Converts an RGB vector V to a number in digital screen format. N Specifies a mode, either 0, 2 or 3, corresponding to Digital Screen color modes."
E2Helper.Descriptions["rgb2digi(nn2n3n4)"] = "Converts the RGB color (N,N2,N3) to a number in digital screen format. N4 Specifies a mode, either 0, 2 or 3, corresponding to Digital Screen color modes."

-- Entity Discovery
E2Helper.Descriptions["findUpdateRate()"] = "Returns the minimum delay between entity find events on a chip"
E2Helper.Descriptions["findPlayerUpdateRate()"] = "Returns the minimum delay between entity find events per player"
E2Helper.Descriptions["findCanQuery()"] = "Returns 1 if find functions can be used, 0 otherwise."
E2Helper.Descriptions["findInSphere(vn)"] = "Finds entities in a sphere around V with a radius of N, returns the number found after filtering"
E2Helper.Descriptions["findInCone(vvnn)"] = "Like findInSphere but with a http://mathworld.wolfram.com/SphericalCone.html Spherical cone, arguments are for position, direction, length, and degrees (works now)"
E2Helper.Descriptions["findInBox(vv)"] = "Like findInSphere but with a globally aligned box, the arguments are the diagonal corners of the box"
E2Helper.Descriptions["findByName(s)"] = "Find all entities with the given name"
E2Helper.Descriptions["findByModel(s)"] = "Find all entities with the given model"
E2Helper.Descriptions["findByClass(s)"] = "Find all entities with the given class"
E2Helper.Descriptions["findPlayerByName(s)"] = "Returns the player with the given name, this is an exception to the rule"
E2Helper.Descriptions["findResult(n)"] = "Returns the indexed entity from the previous find event (valid parameters are 1 to the number of entities found)"
E2Helper.Descriptions["findClosest(v)"] = "Returns the closest entity to the given point from the previous find event"
E2Helper.Descriptions["findToArray()"] = "Formats the query as an array, R[Index,entity] to get an entity."
E2Helper.Descriptions["find()"] = "Equivalent to findResult(1)"
E2Helper.Descriptions["findSortByDistance(v)"] = "Sorts the entities from the last find event, index 1 is the closest to point V, returns the number of entities in the list"
E2Helper.Descriptions["findClipToClass(s)"] = "Filters the list of entities by removing all entities that are NOT of this class"
E2Helper.Descriptions["findClipFromClass(s)"] = "Filters the list of entities by removing all entities that are of this class"
E2Helper.Descriptions["findClipToModel(s)"] = "Filters the list of entities by removing all entities that do NOT have this model"
E2Helper.Descriptions["findClipFromModel(s)"] = "Filters the list of entities by removing all entities that do have this model"
E2Helper.Descriptions["findClipToName(s)"] = "Filters the list of entities by removing all entities that do NOT have this name"
E2Helper.Descriptions["findClipFromName(s)"] = "Filters the list of entities by removing all entities that do have this name"
E2Helper.Descriptions["findClipToSphere(vn)"] = "Filters the list of entities by removing all entities NOT within the specified sphere (center, radius)"
E2Helper.Descriptions["findClipFromSphere(vn)"] = "Filters the list of entities by removing all entities within the specified sphere (center, radius)"
E2Helper.Descriptions["findClipToRegion(vv2)"] = "Filters the list of entities by removing all entities NOT on the positive side of the defined plane. (Plane origin, vector perpendicular to the plane) You can define any convex hull using this."

-- Ranger
E2Helper.Descriptions["rangerFlags()"] = "Returns the ranger flags as a string."
E2Helper.Descriptions["ranger(n)"] = "You input max range, it returns ranger data"
E2Helper.Descriptions["ranger(nnn)"] = "Same as above with added inputs for X and Y skew"
E2Helper.Descriptions["rangerAngle(nnn)"] = "You input the distance, x-angle and y-angle (both in degrees) it returns ranger data"
E2Helper.Descriptions["rangerOffset(vv)"] = "You input two vector points, it returns ranger data"
E2Helper.Descriptions["rangerOffset(nvv)"] = "You input the range, a position vector, and a direction vector and it returns ranger data"
E2Helper.Descriptions["rangerHull(nv)"] = "Inputs: Distance, Hull BoxSize"
E2Helper.Descriptions["rangerHull(nvv)"] = "Input: Distance, Hull MinSize, Hull MaxSize"
E2Helper.Descriptions["rangerHull(nnnv)"] = "Inputs: Distance, X Skew, Y Skew, Hull BoxSize"
E2Helper.Descriptions["rangerHull(nnnvv)"] = "Inputs: Distance, X Skew, Y Skew, Hull MinSize, Hull MaxSize"
E2Helper.Descriptions["rangerHullAngle(nnnv)"] = "Inputs: Distance, X Angle, Y Angle, Hull BoxSize"
E2Helper.Descriptions["rangerHullAngle(nnnvv)"] = "Inputs: Distance, X Angle, Y Angle, Hull MinSize, Hull MaxSize"
E2Helper.Descriptions["rangerOffsetHull(vvv)"] = "Inputs: StartPos, EndPos, Hull BoxSize"
E2Helper.Descriptions["rangerOffsetHull(vvvv)"] = "Inputs: StartPos, EndPos, Hull MinSize, Hull MaxSize"
E2Helper.Descriptions["rangerOffsetHull(nvvv)"] = "Inputs: Distance, StartPos, Direction, Hull BoxSize"
E2Helper.Descriptions["rangerOffsetHull(nvvvv)"] = "Inputs: Distance, StartPos, Direction, Hull MinSize, Hull MaxSize"
E2Helper.Descriptions["distance(rd:)"] = "Outputs the distance from the rangerdata input, else depends on rangerDefault"
E2Helper.Descriptions["position(rd:)"] = "Outputs the position of the input ranger data trace IF it hit anything, else returns (0,0,0)"
E2Helper.Descriptions["entity(rd:)"] = "Returns the entity of the input ranger data trace IF it hit an entity, else returns nil"
E2Helper.Descriptions["hit(rd:)"] = "Returns 1 if the input ranger data hit anything and 0 if it didn't"
E2Helper.Descriptions["hitNormal(rd:)"] = "Outputs a normalized vector perpendicular to the surface the ranger is pointed at."

E2Helper.Descriptions["soundDuration(s)"] = "soundDuration(string Path to File) Returns the duration of the sound. Note: If the server hasn't the file it returns 60"

-- NPCs
E2Helper.Descriptions["npcGetTarget(e:)"] = "Returns what the npc is currently targeting."
E2Helper.Descriptions["npcRelationshipByOwner(e:esn)"] = " Sets the NPC's relationship to all currently existing NPCs owned by player E. Returns number of entities added to relationships."
E2Helper.Descriptions["npcDisp(e:e)"] = " Returns the NPC's relationship to entity E."

-- Signals
E2Helper.Descriptions["signalGetGroup()"] = "Gets the E-2's current signal group"
E2Helper.Descriptions["signalClk()"] = "Returns 1 if the chip was executed because of any signal, regardless of name, group or scope. Returns 0 otherwise."
E2Helper.Descriptions["signalClk(s)"] = "Returns 1 if the chip was executed because the signal S was sent, regardless of group or scope. Returns 0 otherwise."
E2Helper.Descriptions["signalClk(sn)"] = "Returns 1 if the chip was executed because the signal S was sent to the scope N, regardless of group. Returns 0 otherwise."
E2Helper.Descriptions["signalClk(ss2)"] = "Returns 1 if the chip was executed because the signal S2 was sent in the group S, regardless of scope. Returns 0 otherwise."
E2Helper.Descriptions["signalClk(ss2n)"] = "Returns 1 if the chip was executed because the signal S2 was sent in the group S to the scope N. Returns 0 otherwise."
E2Helper.Descriptions["signalName()"] = "Returns the name of the received signal."
E2Helper.Descriptions["signalGroup()"] = "Returns the group name of the received signal."
E2Helper.Descriptions["signalSender()"] = "Returns the entity of the chip that sent the signal."
E2Helper.Descriptions["signalSenderId()"] = "Returns the entity ID of the chip that sent the signal. Useful if the entity doesn't exist anymore."

-- Glon
E2Helper.Descriptions["glonEncode(r)"] = "Encodes R into a string, using GLON."
E2Helper.Descriptions["glonEncode(t)"] = "Encodes T into a string, using GLON."
E2Helper.Descriptions["glonDecode(s)"] = "Decodes S into an array, using GLON."
E2Helper.Descriptions["glonDecodeTable(s)"] = "Decodes S into a table, using GLON."

-- Holograms
E2Helper.Descriptions["holoEntity(n)"] = "Returns the entity corresponding to the hologram given by the specified index."
E2Helper.Descriptions["holoIndex(e)"] = "Returns the index of the given hologram entity."
E2Helper.Descriptions["holoCanCreate()"] = "Returns 1 when holoCreate() will successfully create a new hologram until the Max limit is reached\nReplaces holoRemainingSpawns()"
E2Helper.Descriptions["holoCreate(nvvav)"] = "Index, Position, Scale, Angle, Color (RGB)\nCreates a new hologram entity"
E2Helper.Descriptions["holoCreate(nvva)"] = "Index, Position, Scale, Angle\nCreates a new hologram entity"
E2Helper.Descriptions["holoCreate(nvv)"] = "Index, Position, Scale\nCreates a new hologram entity"
E2Helper.Descriptions["holoCreate(nv)"] = "Index, Position\nCreates a new hologram entity"
E2Helper.Descriptions["holoCreate(n)"] = "Index\nCreates a new hologram entity"
E2Helper.Descriptions["holoScale(n)"] = "Index\nReturns the scale of the given hologram"
E2Helper.Descriptions["holoScaleUnits(n)"] = "Index\nReturns the scale of the given hologram"

-- File
E2Helper.Descriptions["fileLoaded(s)"] = "Returns whether or not the file has been loaded onto the server."
E2Helper.Descriptions["fileRead(s)"] = "Returns the string data from a given file (has to be loaded onto server)."
E2Helper.Descriptions["fileClk(s)"] = "Returns whether the execution was run because a file finished uploading and was that file of a specific file name."
E2Helper.Descriptions["fileClk()"] = "Returns whether the execution was run because a file finished uploading."
E2Helper.Descriptions["fileListLoaded()"] = "If the list has been loaded and it is called, it will return 1. Any time after that until a new list is loaded it will return 0."
E2Helper.Descriptions["fileList()"] = "Returns an array of file names that have been loaded."
E2Helper.Descriptions["fileListTable()"] = "Returns a table of file names that have been loaded. (Tbl[\"filename\"] = \"filename\")"
E2Helper.Descriptions["fileListClk()"] = "Returns whether the execution was run because a list was uploaded to the server."

-- Datasignals
E2Helper.Descriptions["dsSend"] = "Sends a datasignal to the specified group and scope."
E2Helper.Descriptions["dsSendDirect"] = "Sends a datasignal to the specified E2 (or use an array for several E2s)."
E2Helper.Descriptions["dsGetSender()"] = "Returns the entity of the E2 which sent the signal."
E2Helper.Descriptions["dsJoinGroup(s)"] = "Join the group to receive signals from it."
E2Helper.Descriptions["dsLeaveGroup(s)"] = "Leave the group to stop receiving signals from it."
E2Helper.Descriptions["dsClearGroups()"] = "Leave all groups."
E2Helper.Descriptions["dsClk()"] = "Returns 1 if the current execution was caused by a datasignal."
E2Helper.Descriptions["dsClk(s)"] = "Returns 1 if the current execution was caused by a datasignal with the specified signal name."
E2Helper.Descriptions["dsClkName()"] = "Returns the name of the signal."
E2Helper.Descriptions["dsGetType()"] = "Returns the type of the received data."
E2Helper.Descriptions["dsGetGroups()"] = "Returns an array of the groups the E2 is in."
E2Helper.Descriptions["dsGetGroup()"] = "Get the name of the group the signal was sent to."
E2Helper.Descriptions["dsProbe"] = "Returns an array of E2s the signal would have been sent to if it had been sent with the specified arguments."
E2Helper.Descriptions["dsSetScope(n)"] = "Sets the scope of the E2. Setting the scope determines which signals the E2 can receive. Check the wiki for more info about scopes."
E2Helper.Descriptions["dsGetScope()"] = "Returns the scope the E2 is currently in."

-- gvars
E2Helper.Descriptions["gTable(sn)"] = "Returns the gTable. The string determines group, and the number determines wether or not the table should be shared."
E2Helper.Descriptions["gRemoveAll()"] = "Removes all non-shared variables and group tables you have created."

-- tables
E2Helper.Descriptions["table"] = "Returns a table with the values specified in the array-part."
--E2Helper.Descriptions["toTable(t:)"] = "Converts the table into an table. (Note that there is no Array:totable() function because E2 arrays do not save typeids)"
E2Helper.Descriptions["clear(t:)"] = "Clears the table."
E2Helper.Descriptions["count(t:)"] = "Returns the number of entries in the table. Does not add the entries in subtables."
E2Helper.Descriptions["depth(t:)"] = "Returns the depth at which the table is in, relative to its parents."
E2Helper.Descriptions["flip(t:)"] = "Returns a flipped copy of the table. Only affects string values in the array part and number values in the table part."
E2Helper.Descriptions["typeids(t:)"] = "Returns a new table with the typeids of the table"
E2Helper.Descriptions["remove(t:n)"] = "Removes the specified entry from the array-part."
E2Helper.Descriptions["remove(t:s)"] = "Removes the specified entry from the table-part."
E2Helper.Descriptions["clipToTypeid(t:s)"] = "Removes all entries not of the specified type."
E2Helper.Descriptions["clipFromTypeid(t:s)"] = "Removes all entries of the specified type."
E2Helper.Descriptions["pop(t:)"] = "Removes the last entry in the array-part."
E2Helper.Descriptions["min(t:)"] = "Returns the smallest numerical entry in the array-part."
E2Helper.Descriptions["max(t:)"] = "Returns the largest numerical entry in the array-part."
E2Helper.Descriptions["minIndex(t:)"] = "Returns the index of the smallest numerical entry in the array-part."
E2Helper.Descriptions["maxIndex(t:)"] = "Returns the index of the largest numerical entry in the array-part."
E2Helper.Descriptions["typeidsArray(t:)"] = "Returns an array with the typeids of the array-part of the table."
E2Helper.Descriptions["toArray(t:)"] = "Converts the table into an array. (Note that there is no R:totable() function because E2 arrays do not save typeids)"
E2Helper.Descriptions["findToTable()"] = "Inserts the finds from an entity discovery event into an table's array-part and returns it. (Basically the same as findToArray())"
E2Helper.Descriptions["toTable(t:)"] = "Converts the table into a table."
E2Helper.Descriptions["typeidsTable(t:)"] = "Returns a table with the typeids of the table-part of the table."
E2Helper.Descriptions["clone(t:)"] = "Returns a copy of the table."
E2Helper.Descriptions["concat(t:)"] = "Concatenates the array-part of the table."
E2Helper.Descriptions["concat(t:s)"] = "Concatenates the array-part of the table, with a string delimiter."
E2Helper.Descriptions["toString(t:)"] = "Formats the table as a human-readable string."
E2Helper.Descriptions["id(t:)"] = "Returns the unique ID of the table."
end
